home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / gnu / gnumake / pdmake.zoo / macro.c < prev    next >
C/C++ Source or Header  |  1991-09-25  |  4KB  |  172 lines
  1.     /***************************************************************\
  2.     *                                *
  3.     *  PDMAKE, Atari ST version                    *
  4.     *                                *
  5.     *  Adapted from mod.sources Vol 7 Issue 71, 1986-12-03.        *
  6.     *                                *
  7.     *  This port makes extensive use of the original net.sources    *
  8.     *  port by Jwahar Bammi.                    *
  9.     *                                *
  10.     *      Ton van Overbeek                        *
  11.     *      Email: TPC862@ESTEC.BITNET                *
  12.     *             TPC862%ESTEC.BITNET@WISCVM.WISC.EDU    (ARPA)    *
  13.     *             ...!mcvax!tpc862%estec.bitnet   (UUCP Europe)    *
  14.     *             ...!ucbvax!tpc862%estec.bitnet  (UUCP U.S.A.)    *
  15.     *             71450,3537  (CompuServe)                *
  16.     *                                *
  17.     \***************************************************************/
  18.  
  19. /*
  20.  *    Macro control for make
  21.  */
  22.  
  23. #include "h.h"
  24.  
  25. struct macro *    macrohead;
  26.  
  27. struct macro *
  28. getmp(name)
  29. char *    name;
  30. {
  31.     register struct macro *    rp;
  32.  
  33.     for (rp = macrohead; rp; rp = rp->m_next)
  34.         if (strcmp(name, rp->m_name) == 0)
  35.             return rp;
  36.     return (struct macro *)0;
  37. }
  38.  
  39.  
  40. char *
  41. getmacro(name)
  42. char *    name;
  43. {
  44.     struct macro *    mp;
  45.  
  46.     if (mp = getmp(name))
  47.         return mp->m_val;
  48.     else
  49.         return "";
  50. }
  51.  
  52.  
  53. struct macro *
  54. setmacro(name, val)
  55. char *    name;
  56. char *    val;
  57. {
  58.     register struct macro *    rp;
  59.     register char *        cp;
  60.  
  61.  
  62.             /*  Replace macro definition if it exists  */
  63.     for (rp = macrohead; rp; rp = rp->m_next)
  64.         if (strcmp(name, rp->m_name) == 0)
  65.         {
  66.             free(rp->m_val);        /*  Free space from old  */
  67.             break;
  68.         }
  69.  
  70.     if (!rp)        /*  If not defined, allocate space for new  */
  71.     {
  72.         if ((rp = (struct macro *)malloc(sizeof (struct macro)))
  73.                      == (struct macro *)0)
  74.             fatal("No memory for macro");
  75.  
  76.         rp->m_next = macrohead;
  77.         macrohead = rp;
  78.         rp->m_flag = FALSE;
  79.  
  80.         if ((cp = malloc(strlen(name)+1)) == (char *)0)
  81.             fatal("No memory for macro");
  82.         strcpy(cp, name);
  83.         rp->m_name = cp;
  84.     }
  85.  
  86.     if ((cp = malloc(strlen(val)+1)) == (char *)0)
  87.         fatal("No memory for macro");
  88.     strcpy(cp, val);            /*  Copy in new value  */
  89.     rp->m_val = cp;
  90.  
  91.     return rp;
  92. }
  93.  
  94.  
  95. /*
  96.  *    Do the dirty work for expand
  97.  */
  98. void
  99. doexp(to, from, len, buf)
  100. char **    to;
  101. char *    from;
  102. int *    len;
  103. char *    buf;
  104. {
  105.     register char *        rp;
  106.     register char *        p;
  107.     register char *        q;
  108.     register struct macro *    mp;
  109.  
  110.  
  111.     rp = from;
  112.     p = *to;
  113.     while (*rp)
  114.     {
  115.         if (*rp != '$')
  116.         {
  117.             *p++ = *rp++;
  118.             (*len)--;
  119.         }
  120.         else
  121.         {
  122.             q = buf;
  123.             if (*++rp == '{')
  124.                 while (*++rp && *rp != '}')
  125.                     *q++ = *rp;
  126.             else if (*rp == '(')
  127.                 while (*++rp && *rp != ')')
  128.                     *q++ = *rp;
  129.             else if (!*rp)
  130.             {
  131.                 *p++ = '$';
  132.                 break;
  133.             }
  134.             else
  135.                 *q++ = *rp;
  136.             *q = '\0';
  137.             if (*rp)
  138.                 rp++;
  139.             if (!(mp = getmp(buf)))
  140.                 mp = setmacro(buf, "");
  141.             if (mp->m_flag)
  142.                 fatal("Infinitely recursive macro %s", mp->m_name);
  143.             mp->m_flag = TRUE;
  144.             *to = p;
  145.             doexp(to, mp->m_val, len, buf);
  146.             p = *to;
  147.             mp->m_flag = FALSE;
  148.         }
  149.         if (*len <= 0)
  150.             error("Expanded line too line");
  151.     }
  152.     *p = '\0';
  153.     *to = p;
  154. }
  155.  
  156.  
  157. /*
  158.  *    Expand any macros in str.
  159.  */
  160. void
  161. expand(str)
  162. char *        str;
  163. {
  164.     static char    a[LZ];
  165.     static char    b[LZ];
  166.     char *    p = str;
  167.     int        len = LZ-1;
  168.  
  169.     strcpy(a, str);
  170.     doexp(&p, a, &len, b);
  171. }
  172.